﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ReadAndWrite
{
    /// <summary>
    /// Cette classe permet de lire et d'écrire dans un fichier un texte.
    /// Elle représente donc une stratégie d'écriture et de lecture. 
    /// Ce design pattern est le pattern Strategy qui permet d'etre modulaire, et facilement évoluable.
    /// </summary>
    public class ReadAndWrite
    {
        #region Propriété(s)

        /// <summary>
        /// Chemin du fichier (Accessible en lecture et écriture).
        /// </summary>
        public String Path
        {
            get;
            set;
        }

        #endregion

        #region Constructeur(s)

        /// <summary>
        /// Constructeur sans paramètres
        /// </summary>
        public ReadAndWrite():this(String.Empty)
        {
        }

        /// <summary>
        /// Constructeur avec paramètre
        /// </summary>
        /// <param name="path"></param>
        public ReadAndWrite(String path)
        {
            Path = path;
        }

        #endregion

        #region Méthode(s)

        /// <summary>
        /// Permet de lire l'intégralité du fichier spécifié par Path 
        /// et retourne donc une String contenant l'ensemble des données texte.
        /// </summary>
        /// <returns>Retourne tout le contenu du fichier texte.</returns>
        public String Read()
        {
            String texte = String.Empty;

            try{texte = System.IO.File.ReadAllText(Path);}
            catch (Exception){}

            return texte;
        }

        /// <summary>
        /// Permet de lire l'intégralité du fichier spécifié par Path 
        /// et retourne un tableau de lignes du fihcier.
        /// </summary>
        /// <returns>Retourne un tableau de string représentant le tableau des lignes dans le fichier</returns>
        public string[] ReadLines()
        {
            string[] tab = null;

            try { tab = System.IO.File.ReadAllLines(Path); }
            catch (Exception) { }

            return tab;
        }

        /// <summary>
        /// Permet d'écrire du contenu dans un fichier. 
        /// Si le fichier existe déjà, le contenu existant sera effacé 
        /// et remplacer par le nouveau.
        /// </summary>
        /// <param name="texte">Contenu à écrire dans le fichier</param>
        /// <returns>Retourne un booléen qui permet de savoir si l'écriture a bien été effectué.</returns>
        public bool Write(String texte)
        {
            try
            {
                //if (File.Exists(Path))
                //    File.Delete(Path);

                //if (File.Exists(Path))
                //{
                //    String textRead = File.ReadAllText(Path);
                //    StringBuilder build = new StringBuilder();

                //    //build.Append(textRead != null ? textRead : String.Empty)
                //    //    .Append(Environment.NewLine)
                //    //    .Append(texte != null ? texte : String.Empty);
                //    build.Append(textRead != null ? textRead : String.Empty)
                //        .Append(texte != null ? texte : String.Empty);

                    
                //    System.IO.File.WriteAllText(Path, build.ToString());
                //}
                //else
                //    System.IO.File.WriteAllText(Path, texte != null ? texte : String.Empty);

                StreamWriter stream = new StreamWriter(Path, true, Encoding.UTF8);
                stream.AutoFlush = true;
                stream.Write(texte != null ? texte : String.Empty);
                stream.Close();

                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        #endregion
    }
}
